using System.Collections;
using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// 灵活的Entity设计 - 组件可选，按需组合
/// </summary>
public abstract class Entity_Flexible : MonoBehaviour
{
    public EntityData EntityData;
    
    // 组件缓存 - 按需获取，不强求存在
    private Dictionary<System.Type, Component> m_ComponentCache = new Dictionary<System.Type, Component>();
    
    // 基础属性
    public bool IsStealth { get; private set; }
    public bool IsSuperArmor { get; private set; }
    
    protected virtual void Awake()
    {
        this.Initialize();
    }

    /// <summary>
    /// 获取组件 - 支持可选组件
    /// </summary>
    public T GetEntityComponent<T>() where T : Component
    {
        var type = typeof(T);
        
        if (m_ComponentCache.TryGetValue(type, out var cachedComponent))
        {
            return cachedComponent as T;
        }
        
        var component = GetComponent<T>();
        if (component != null)
        {
            m_ComponentCache[type] = component;
        }
        
        return component;
    }

    /// <summary>
    /// 检查是否有指定组件
    /// </summary>
    public bool HasComponent<T>() where T : Component
    {
        return GetEntityComponent<T>() != null;
    }

    /// <summary>
    /// 初始化 - 只初始化存在的组件
    /// </summary>
    public virtual void Initialize()
    {
        // 按需初始化组件，不强求所有组件都存在
        
        // 生命值组件 - 大部分实体都需要
        var healthComponent = GetEntityComponent<HealthComponent>();
        if (healthComponent != null)
        {
            healthComponent.Initialize(EntityData.Health);
        }
        
        // 属性组件 - 大部分实体都需要
        var attrComponent = GetEntityComponent<AttrComponent>();
        if (attrComponent != null)
        {
            attrComponent.Initialize();
        }
        
        // 移动组件 - 只有需要移动的实体才有
        var moveComponent = GetEntityComponent<MoveComponent>();
        if (moveComponent != null)
        {
            moveComponent.Initialize(EntityData.Speed);
        }
        
        // 攻击组件 - 只有需要攻击的实体才有
        var attackComponent = GetEntityComponent<AttackComponent>();
        if (attackComponent != null)
        {
            attackComponent.Initialize(EntityData.AttackData);
        }
        
        // 状态机组件 - 只有需要复杂状态管理的实体才有
        var fsmComponent = GetEntityComponent<FSMComponent>();
        if (fsmComponent != null)
        {
            fsmComponent.Initialize();
        }
        
        // Buff组件 - 只有需要Buff系统的实体才有
        var buffComponent = GetEntityComponent<BuffComponent>();
        if (buffComponent != null)
        {
            // Buff组件初始化
        }
        
        // 技能指示器 - 只有需要技能显示的实体才有
        var skillIndicators = GetEntityComponent<SkillAttackIndicators>();
        if (skillIndicators != null)
        {
            skillIndicators.Initialize();
        }
    }

    /// <summary>
    /// 设置隐身状态
    /// </summary>
    public void SetStealth(bool stealth)
    {
        IsStealth = stealth;
    }

    /// <summary>
    /// 设置超级护甲状态
    /// </summary>
    public void SetSuperArmor(bool superArmor)
    {
        IsSuperArmor = superArmor;
    }

    /// <summary>
    /// 获取无敌状态 - 安全访问
    /// </summary>
    public bool IsInvincible 
    { 
        get 
        { 
            var health = GetEntityComponent<HealthComponent>();
            return health?.IsInvincible ?? false;
        } 
    }
}

/// <summary>
/// 向日葵 - 只需要生命值和阳光生产
/// </summary>
public class Sunflower : Entity_Flexible
{
    private SunProductionComponent m_SunProduction;
    
    protected override void Awake()
    {
        // 向日葵只需要这些组件：
        // - HealthComponent (生命值)
        // - AttrComponent (属性) 
        // - SunProductionComponent (阳光生产)
        // 不需要：AttackComponent, MoveComponent, FSMComponent等
        
        base.Awake();
        m_SunProduction = GetEntityComponent<SunProductionComponent>();
    }
    
    public override void Initialize()
    {
        base.Initialize();
        
        // 初始化阳光生产组件
        if (m_SunProduction != null)
        {
            m_SunProduction.Initialize();
        }
    }
}

/// <summary>
/// 飞行僵尸 - 需要移动、攻击、飞行能力
/// </summary>
public class FlyingZombie : Entity_Flexible
{
    private FlyingComponent m_FlyingComponent;
    
    protected override void Awake()
    {
        // 飞行僵尸需要：
        // - HealthComponent (生命值)
        // - MoveComponent (移动)
        // - AttackComponent (攻击)
        // - FlyingComponent (飞行)
        // - FSMComponent (状态机)
        
        base.Awake();
        m_FlyingComponent = GetEntityComponent<FlyingComponent>();
    }
    
    public override void Initialize()
    {
        base.Initialize();
        
        // 初始化飞行组件
        if (m_FlyingComponent != null)
        {
            m_FlyingComponent.Initialize();
        }
    }
}

/// <summary>
/// 装饰性植物 - 只需要生命值，不需要其他功能
/// </summary>
public class DecorativePlant : Entity_Flexible
{
    protected override void Awake()
    {
        // 装饰性植物只需要：
        // - HealthComponent (生命值)
        // 不需要：移动、攻击、状态机等任何其他组件
        
        base.Awake();
    }
    
    public override void Initialize()
    {
        // 只初始化基础的生命值组件
        base.Initialize();
        // 不需要其他组件的初始化
    }
}
